/**
 * BattleBridge - 页面与Cocos iframe通信桥接类
 * 提供统一的命令发送、接收和管理功能
 */
class BattleBridge {
    constructor() {
        this.iframe = null;
        this.iframeReady = false;
        this.commandCallbacks = {};
        this.messageQueue = [];
        this.logCallback = null;
        this.debugMode = false;
    }

    /**
     * 初始化battleBridge
     * @param {HTMLIFrameElement} iframe - 目标iframe元素
     * @param {Function} logCallback - 日志回调函数
     */
    init(iframe, logCallback = null) {
        this.iframe = iframe;
        this.logCallback = logCallback;
        this.setupMessageListener();
        this.log('BattleBridge初始化完成', 'info');
    }

    /**
     * 设置消息监听器
     */
    setupMessageListener() {
        if (!window.addEventListener) return;

        window.addEventListener('message', (event) => {
            this.handleIframeMessage(event);
        });

        // 等待iframe发送ready消息
        this.log('等待iframe准备就绪...', 'info');
    }

    /**
     * 处理来自iframe的消息
     */
    handleIframeMessage(event) {
        if (!event.data) return;

        const data = event.data;

        // 处理ready消息
        if (data && data.type === 'ready') {
            this.iframeReady = true;
            this.log('iframe已准备就绪', 'success');
            this.processMessageQueue();
            return;
        }

        // 处理命令回调
        if (data.commandId && this.commandCallbacks[data.commandId]) {
            this.commandCallbacks[data.commandId](data);
            delete this.commandCallbacks[data.commandId];
        }

        this.log(`收到iframe消息: ${JSON.stringify(data)}`, 'info');
    }

    /**
     * 处理来自Cocos的消息（供Cocos调用）
     */
    handleMessage(data) {
        this.log(`收到Cocos消息: ${JSON.stringify(data)}`, 'info');

        // 处理ready消息
        if (data && data.type === 'ready') {
            this.iframeReady = true;
            this.log('Cocos已准备就绪', 'success');
            this.processMessageQueue();
            return;
        }

    }

    /**
     * 处理消息队列
     */
    processMessageQueue() {
        while (this.messageQueue.length > 0) {
            const message = this.messageQueue.shift();
            this.sendToIframe(message);
        }
    }

    /**
     * 发送消息到iframe
     */
    sendToIframe(data) {
        if (!this.iframe) {
            this.log('iframe未初始化', 'error');
            return;
        }

        if (!this.iframeReady) {
            this.log('iframe未准备就绪，消息加入队列', 'warning');
            this.messageQueue.push(data);
            return;
        }

        if (this.iframeReady && this.iframe.contentWindow) {
            try {
                this.iframe.contentWindow.postMessage(data, '*');
                // this.log(`发送消息到iframe: ${JSON.stringify(data)}`, 'info');
            } catch (e) {
                this.log(`发送消息失败: ${e.message}`, 'error');
            }
        }
    }

    /**
     * 发送命令
     */
    sendCommand(command) {
        const message = {
            type: 'command',
            data: command
        };

        this.sendToIframe(message);
    }

    /**
     * 生成命令ID
     */
    generateCommandId() {
        return 'cmd_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    }

    /**
     * 添加命令回调
     */
    addCommandCallback(commandId, callback) {
        this.commandCallbacks[commandId] = callback;
    }

    /**
     * 发送初始化命令（用于回放页面）
     */
    sendInitCommand(initData) {
        const command = {
            type: 'init',
            ...initData,
        };
        this.sendCommand(command);
        this.log('发送初始化命令', 'system');
    }

    /**
     * 发送回放命令（用于回放页面）
     */
    sendReplayCommand(roundCommand) {
        this.sendCommand(roundCommand);
        this.log(`发送回合命令: ${roundCommand.type}`, 'system');
    }

    /**
     * 重置战斗（用于回放页面）
     */
    resetBattle() {
        const resetCommand = {
            type: 'reset',
            player: 'server',
            round: 0,
            self: null,
            target: null,
            param: null
        };
        this.sendCommand(resetCommand);
        this.log('发送重置命令', 'system');
    }

    /**
     * 设置调试模式
     */
    setDebugMode(enabled) {
        this.debugMode = enabled;
        this.log(`调试模式: ${enabled ? '开启' : '关闭'}`, 'info');
    }

    /**
     * 日志输出
     */
    log(message, type = 'info') {
        const timestamp = new Date().toLocaleTimeString();
        const logMessage = `[${timestamp}] [BattleBridge] ${message}`;

        if (this.logCallback) {
            this.logCallback(logMessage, type);
        } else {
            console.log(`[BattleBridge] ${message}`);
        }
    }

    /**
     * 验证并发送命令（用于战斗页面）
     */
    validateAndSendCommand(command) {
        // 生成命令ID
        const commandId = this.generateCommandId();
        command.commandId = commandId;

        this.log(`验证命令: ${command.type}`, 'info');

        // 这里可以添加具体的验证逻辑
        // 目前直接发送
        this.sendCommand(command);
    }

    /**
     * 处理玩家命令（用于战斗页面）
     */
    handlePlayerCommand(data) {
        // 生成命令ID
        const commandId = this.generateCommandId();
        data.commandId = commandId;

        this.log(`处理玩家命令: ${data.commandType || data.type}`, 'command');

        // 在调试模式下，直接发送
        if (this.debugMode) {
            this.log('调试模式: 直接发送命令', 'info');
            const message = {
                data: data.commandData || data,
            };
            this.sendToIframe(message);
            return;
        }

        // 正常模式下进行验证
        this.validateAndSendCommand(data);
    }

    /**
     * 发送JSON命令（用于调试）
     */
    sendJsonCommand(jsonText) {
        if (!jsonText) {
            this.log('请输入JSON命令', 'error');
            return;
        }

        try {
            const command = JSON.parse(jsonText);
            this.sendCommand(command);
            this.log('JSON命令已发送', 'info');
        } catch (e) {
            this.log('JSON格式错误: ' + e.message, 'error');
        }
    }

    /**
     * 销毁battleBridge
     */
    destroy() {
        this.commandCallbacks = {};
        this.messageQueue = [];
        this.iframe = null;
        this.iframeReady = false;
        this.logCallback = null;
    }
}

// 导出到全局
window.BattleBridge = BattleBridge;

// 如果没有全局battleBridge实例，创建一个默认的
if (!window.battleBridge) {
    window.battleBridge = new BattleBridge();
}
